
#include "Encoder.h"

#include "stm32f10x.h"
#include"usart.h"

#define ENCODER_RESOLUTION 500 // 编码器每转脉冲数
#define SAMPLE_TIME_MS 50      // 采样周期

static int16_t prev_count = 0;
static uint32_t prev_time = 0;

#define ENCODER_PPR 500 // 编码器每转脉冲数（根据实际编码器调整）
volatile int32_t last_count = 0;
volatile float rpm = 0.0;

int16_t tim4_count=0;
/**
 * ==================================================
 * 使用定时器3读取编码器
 * 编码器1：PB6（TIM4_CH1），PB7（TIM4_CH2）
 * ==================================================
 */
void GPIO_Encoder_Config(void);
void TIM_Encoder_Config(void);
void TIM_Overflow_IRQ_Config(void);
int16_t Encoder_Get(void);

// 函数：编码器配置
void Encoder_Configuration(void)
{
    // 編碼器读取采用定时器3
    // 调用GPIO编码器配置函数
    GPIO_Encoder_Config();
    // 调用定时器编码器配置函数
    TIM_Encoder_Config();

    // 使用定时器1计时计算rpm
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIM1, ENABLE);

    TIM_TimeBaseInitTypeDef TIM_InitStruct;
    TIM_TimeBaseStructInit(&TIM_InitStruct);
    TIM_InitStruct.TIM_Prescaler = 7200 - 1; // 72MHz / 7200 = 10KHz
    TIM_InitStruct.TIM_Period = 1000 - 1;    // 10KHz下1000次计数 = 0.1秒
    TIM_InitStruct.TIM_CounterMode = TIM_CounterMode_Up;
    TIM_TimeBaseInit(TIM1, &TIM_InitStruct);

    TIM_ITConfig(TIM1, TIM_IT_Update, ENABLE);

    NVIC_InitTypeDef NVIC_InitStruct;
    NVIC_InitStruct.NVIC_IRQChannel = TIM1_UP_IRQn;
    NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 2;
    NVIC_InitStruct.NVIC_IRQChannelSubPriority = 0;
    NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init(&NVIC_InitStruct);

    TIM_Cmd(TIM1, ENABLE);
}

void GPIO_Encoder_Config(void)
{
    // 编码器1：PB6（TIM4_CH1），PB7（TIM4_CH2）
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);

    GPIO_InitTypeDef GPIO_InitStruct;
    GPIO_InitStruct.GPIO_Pin = GPIO_Pin_6 | GPIO_Pin_7;
    GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IPU; //
    GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOB, &GPIO_InitStruct);
}

void TIM_Encoder_Config(void)
{
    // ----------------- 编码器1：TIM4 -----------------
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM4, ENABLE);
    // 时基配置（实际频率由编码器信号决定）
    TIM_TimeBaseInitTypeDef TIM_TimeBaseStruct;
    TIM_TimeBaseStructInit(&TIM_TimeBaseStruct);
    TIM_TimeBaseStruct.TIM_Prescaler = 0;   // 无分频
    TIM_TimeBaseStruct.TIM_Period = 0xFFFF; // 16位计数器最大值
    TIM_TimeBaseStruct.TIM_CounterMode = TIM_CounterMode_Up;
    TIM_TimeBaseStruct.TIM_ClockDivision = TIM_CKD_DIV1;
    TIM_TimeBaseInit(TIM4, &TIM_TimeBaseStruct);

    // 编码器模式配置（四倍频，X4模式）
    TIM_ICInitTypeDef TIM_ICInitStruct;
    TIM_ICStructInit(&TIM_ICInitStruct);
    TIM_ICInitStruct.TIM_Channel = TIM_Channel_1 | TIM_Channel_2;
    TIM_ICInitStruct.TIM_ICFilter = 0x06;                        // 滤波系数（根据信号质量调整）
    TIM_ICInitStruct.TIM_ICPolarity = TIM_ICPolarity_Rising;     // 上升沿捕获
    TIM_ICInitStruct.TIM_ICSelection = TIM_ICSelection_DirectTI; // 直接映射
    TIM_ICInitStruct.TIM_ICPrescaler = TIM_ICPSC_DIV1;           // 无分频
    TIM_ICInit(TIM4, &TIM_ICInitStruct);

    // 编码器接口配置
    TIM_EncoderInterfaceConfig(TIM4, TIM_EncoderMode_TI12, TIM_ICPolarity_Rising, TIM_ICPolarity_Rising);

    // 使能定时器溢出中断（处理计数器溢出）
//    TIM_ITConfig(TIM4, TIM_IT_Update, ENABLE);
//    NVIC_EnableIRQ(TIM4_IRQn);

//    // 配置NVIC中断优先级
//    NVIC_InitTypeDef NVIC_InitStruct;
//    NVIC_InitStruct.NVIC_IRQChannel = TIM4_IRQn;
//    NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 1;
//    NVIC_InitStruct.NVIC_IRQChannelSubPriority = 0;
//    NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;
//    NVIC_Init(&NVIC_InitStruct);

//    TIM_ClearFlag(TIM4, TIM_FLAG_Update); // 清除溢出标志位

    TIM_Cmd(TIM4, ENABLE); // 启动TIM4
}

//int16_t Encoder_GetCount(void)
//{
//    return TIM_GetCounter(TIM4); // 返回当前计数值（范围0~65535）
//}

// 使用TIM1定时中断（100ms周期）
void TIM1_UP_IRQHandler(void)
{
    if (TIM_GetITStatus(TIM1, TIM_IT_Update))
    {
				int16_t delta_count=Encoder_Get();
        // 计算转速（RPM）
        // 公式：RPM = (delta_count / PPR) * (60 / 采样时间)*(1/减速比)
        rpm = (delta_count * 60.0f) / (ENCODER_PPR * 0.1f*30); // 0.1秒采样时间
        TIM_ClearITPendingBit(TIM1, TIM_IT_Update);
    }
}

volatile int32_t encoder_total = 0; // 全局变量记录总脉冲数

Encoder_Dir Encoder_GetDirection(void)
{
    // 通过CR1寄存器的DIR位判断方向
    if (TIM4->CR1 & TIM_CR1_DIR)
    {
        return ENCODER_DIR_BACKWARD; // 向下计数为反向
    }
    else
    {
        return ENCODER_DIR_FORWARD; // 向上计数为正向
    }
}


int16_t Encoder_Get(void)
{
    /*使用Temp变量作为中继，目的是返回CNT后将其清零*/
//    int16_t Temp;
    tim4_count = TIM_GetCounter(TIM4);
    TIM_SetCounter(TIM4, 0);
    return tim4_count;
}

//// 全局变量记录溢出次数
//volatile int32_t Encoder1_Total = 0;
//volatile int32_t Encoder2_Total = 0;

//// 定时器溢出中断配置
//void TIM_Overflow_IRQ_Config(void)
//{
//    // TIM4溢出中断
//    TIM_ITConfig(TIM4, TIM_IT_Update, ENABLE);
//    NVIC_InitTypeDef NVIC_InitStruct;
//    NVIC_InitStruct.NVIC_IRQChannel = TIM4_IRQn;
//    NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 0;
//    NVIC_InitStruct.NVIC_IRQChannelSubPriority = 0;
//    NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;
//    NVIC_Init(&NVIC_InitStruct);

//    // TIM4溢出中断
//    TIM_ITConfig(TIM4, TIM_IT_Update, ENABLE);
//    NVIC_InitStruct.NVIC_IRQChannel = TIM4_IRQn;
//    NVIC_Init(&NVIC_InitStruct);
//}



//// 读取编码器1的计数值（TIM2）
//int16_t Read_Encoder1(void)
//{
//    return (int16_t)TIM_GetCounter(TIM2); // 返回有符号数（支持正反转）
//}

//// 读取编码器2的计数值（TIM4）
//int16_t Read_Encoder2(void)
//{
//    return (int16_t)TIM_GetCounter(TIM4);
//}



//// 获取扩展后的32位计数值
//int32_t Get_Encoder1_Total(void)
//{
//    int32_t count;
//    TIM2->CNT = 0; // 清零计数器（可选，根据需求调整）
//    count = Encoder1_Total + (int16_t)TIM4->CNT;
//    Encoder1_Total = 0;
//    return count;
//}

//int32_t Get_Encoder2_Total(void)
//{
//    int32_t count;
//    TIM2->CNT = 0; // 清零计数器（可选，根据需求调整）
//    count = Encoder1_Total + (int16_t)TIM4->CNT;
//    Encoder1_Total = 0;
//    return count;
//}


